home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 16 / CU Amiga Magazine's Super CD-ROM 16 (1997-10-16)(EMAP Images)(GB)[!][issue 1997-11].iso / CUCD / Graphics / Ghostscript / source / gdevprn.c < prev    next >
C/C++ Source or Header  |  1997-07-18  |  19KB  |  671 lines
  1. /* Copyright (C) 1990, 1995, 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gdevprn.c */
  20. /* Generic printer driver support */
  21. #include "ctype_.h"
  22. #include "gdevprn.h"
  23. #include "gp.h"
  24. #include "gsparam.h"
  25. #include "gxclio.h"
  26.  
  27. /* ---------------- Standard device procedures ---------------- */
  28.  
  29. /* Macros for casting the pdev argument */
  30. #define ppdev ((gx_device_printer *)pdev)
  31. #define pmemdev ((gx_device_memory *)pdev)
  32. #define pcldev (&((gx_device_clist *)pdev)->common)
  33.  
  34. /* Define the standard printer procedure vector. */
  35. gx_device_procs prn_std_procs =
  36.   prn_procs(gdev_prn_open, gdev_prn_output_page, gdev_prn_close);
  37.  
  38. /* ------ Open/close ------ */
  39.  
  40. /* Forward references */
  41. private int gdev_prn_alloc(P1(gx_device *));
  42. private int gdev_prn_free(P1(gx_device *));
  43.  
  44. /* Open a generic printer device. */
  45. /* Specific devices may wish to extend this. */
  46. int
  47. gdev_prn_open(gx_device *pdev)
  48. {    int code;
  49.     ppdev->file = NULL;
  50.     code = gdev_prn_alloc(pdev);
  51.     if ( code < 0 )
  52.       return code;
  53.     if ( ppdev->OpenOutputFile )
  54.       code = gdev_prn_open_printer(pdev, 1);
  55.     return code;
  56. }
  57.  
  58. /* Allocate buffer space and initialize the device. */
  59. /* We break this out as a separate procedure so that resetting */
  60. /* the page dimensions doesn't have to close and reopen the device. */
  61. private int
  62. gdev_prn_alloc(gx_device *pdev)
  63. {    ulong mem_space;
  64.     byte *base = 0;
  65.     void *left = 0;
  66.  
  67.     memset(ppdev->skip, 0, sizeof(ppdev->skip));
  68.     ppdev->orig_procs = pdev->std_procs;
  69.     mem_space = gdev_mem_bitmap_size(pmemdev);
  70.  
  71.     if ( mem_space >= ppdev->space_params.MaxBitmap ||
  72.          mem_space != (uint)mem_space ||    /* too big to allocate */
  73.          (base = (byte *)gs_malloc((uint)mem_space, 1, "printer buffer")) == 0 ||    /* can't allocate */
  74.          (PRN_MIN_MEMORY_LEFT != 0 &&
  75.           (left = gs_malloc(PRN_MIN_MEMORY_LEFT, 1, "printer memory left")) == 0)    /* not enough left */
  76.        )
  77.     {    /* Buffer the image in a command list. */
  78.         uint space;
  79.         int code;
  80.  
  81.         /* Release the buffer if we allocated it. */
  82.         gs_free(base, (uint)mem_space, 1, "printer buffer(open)");
  83.         for ( space = ppdev->space_params.BufferSpace; ; )
  84.         {    base = (byte *)gs_malloc(space, 1,
  85.                          "command list buffer");
  86.             if ( base != 0 ) break;
  87.             if ( (space >>= 1) < PRN_MIN_BUFFER_SPACE )
  88.               return_error(gs_error_VMerror);    /* no hope */
  89.         }
  90. open_c:        pcldev->data = base;
  91.         pcldev->data_size = space;
  92.         pcldev->target = pdev;
  93.         pcldev->make_buffer_device =
  94.           ppdev->printer_procs.make_buffer_device;
  95.         pcldev->band_params = ppdev->space_params.band;
  96.         ppdev->buf = base;
  97.         ppdev->buffer_space = space;
  98.  
  99.         /* Try opening the command list, to see if we allocated */
  100.         /* enough buffer space. */
  101.         code =
  102.           (*gs_clist_device_procs.open_device)((gx_device *)pcldev);
  103.         if ( code < 0 )
  104.         {    /* If there wasn't enough room, and we haven't */
  105.             /* already shrunk the buffer, try enlarging it. */
  106.             if ( code == gs_error_limitcheck &&
  107.                  space >= ppdev->space_params.BufferSpace
  108.                )
  109.             {    gs_free(base, space, 1,
  110.                     "command list buffer(retry open)");
  111.                 space <<= 1;
  112.                 base = (byte *)gs_malloc(space, 1,
  113.                      "command list buffer(retry open)");
  114.                 ppdev->buf = base;
  115.                 if ( base != 0 )
  116.                   goto open_c;
  117.             }
  118.             /* Failure.  Clean up before exiting. */
  119.             gdev_prn_free(pdev);
  120.             return code;
  121.         }
  122.         ppdev->std_procs = gs_clist_device_procs;
  123.     }
  124.     else
  125.     {    /* Render entirely in memory. */
  126.         int code;
  127.         /* Release the leftover memory. */
  128.         gs_free(left, PRN_MIN_MEMORY_LEFT, 1,
  129.             "printer memory left");
  130.         ppdev->buffer_space = 0;
  131.         code = (*ppdev->printer_procs.make_buffer_device)
  132.           (pmemdev, pdev, pdev->memory, false);
  133.         if ( code < 0 )
  134.           { gs_free(base, space, 1, "command list buffer");
  135.             return code;
  136.           }
  137.         pmemdev->base = base;
  138.     }
  139.  
  140.     /* Synthesize the procedure vector. */
  141.     /* Rendering operations come from the memory or clist device, */
  142.     /* non-rendering come from the printer device. */
  143. #define copy_proc(p) set_dev_proc(ppdev, p, ppdev->orig_procs.p)
  144.     copy_proc(get_initial_matrix);
  145.     copy_proc(output_page);
  146.     copy_proc(close_device);
  147.     copy_proc(map_rgb_color);
  148.     copy_proc(map_color_rgb);
  149.     copy_proc(get_params);
  150.     copy_proc(put_params);
  151.     copy_proc(map_cmyk_color);
  152.     copy_proc(get_xfont_procs);
  153.     copy_proc(get_xfont_device);
  154.     copy_proc(map_rgb_alpha_color);
  155.     /* All printers are page devices, even if they didn't use the */
  156.     /* standard macros for generating their procedure vectors. */
  157.     set_dev_proc(ppdev, get_page_device, gx_page_device_get_page_device);
  158.     copy_proc(get_alpha_bits);
  159.     copy_proc(get_clipping_box);
  160. #undef copy_proc
  161.     /* If we're using a command list, we already opened the device. */
  162.     return (ppdev->buffer_space ?  0 :
  163.         (*dev_proc(pdev, open_device))(pdev));
  164. }
  165.  
  166. /* Generic closing for the printer device. */
  167. /* Specific devices may wish to extend this. */
  168. int
  169. gdev_prn_close(gx_device *pdev)
  170. {    gdev_prn_free(pdev);
  171.     if ( ppdev->file != NULL )
  172.     {    if ( ppdev->file != stdout )
  173.           gp_close_printer(ppdev->file, ppdev->fname);
  174.         ppdev->file = NULL;
  175.     }
  176.     return 0;
  177. }
  178.  
  179. /* Free buffer space and related objects, the inverse of alloc. */
  180. /* Again, we break this out for resetting page dimensions. */
  181. private int
  182. gdev_prn_free(gx_device *pdev)
  183. {    if ( ppdev->buffer_space != 0 )
  184.     {    /* Close files and release storage. */
  185.         (*gs_clist_device_procs.close_device)((gx_device *)pcldev);
  186.         /* Free the buffer */
  187.         gs_free(ppdev->buf, (uint)ppdev->buffer_space, 1,
  188.             "command list buffer(close)");
  189.         ppdev->buf = 0;
  190.         ppdev->buffer_space = 0;
  191.     }
  192.     else
  193.     {    /* Free the memory device bitmap */
  194.         gs_free(pmemdev->base, (uint)gdev_mem_bitmap_size(pmemdev), 1,
  195.             "printer buffer(close)");
  196.         pmemdev->base = 0;
  197.     }
  198.     pdev->std_procs = ppdev->orig_procs;
  199.     return 0;
  200. }
  201.  
  202. /* ------ Get/put parameters ------ */
  203.  
  204. /* Get parameters.  Printer devices add several more parameters */
  205. /* to the default set. */
  206. int
  207. gdev_prn_get_params(gx_device *pdev, gs_param_list *plist)
  208. {    int code = gx_default_get_params(pdev, plist);
  209.     gs_param_string ofns;
  210.  
  211.     if ( code < 0 ||
  212.          (code = param_write_long(plist, "MaxBitmap", &ppdev->space_params.MaxBitmap)) < 0 ||
  213.          (code = param_write_long(plist, "BufferSpace", &ppdev->space_params.BufferSpace)) < 0 ||
  214.          (code = param_write_int(plist, "BandWidth", &ppdev->space_params.band.BandWidth)) < 0 ||
  215.          (code = param_write_int(plist, "BandHeight", &ppdev->space_params.band.BandHeight)) < 0 ||
  216.          (code = param_write_long(plist, "BandBufferSpace", &ppdev->space_params.band.BandBufferSpace)) < 0 ||
  217.          (code = (ppdev->NumCopies_set ?
  218.               param_write_int(plist, "NumCopies", &ppdev->NumCopies) :
  219.               param_write_null(plist, "NumCopies"))) < 0 ||
  220.          (code = param_write_bool(plist, "OpenOutputFile", &ppdev->OpenOutputFile)) < 0 ||
  221.          (ppdev->Duplex_set >= 0 &&
  222.           (code = (ppdev->Duplex_set ?
  223.                param_write_bool(plist, "Duplex", &ppdev->Duplex) :
  224.                param_write_null(plist, "Duplex"))) < 0)
  225.        )
  226.       return code;
  227.  
  228.     ofns.data = (const byte *)ppdev->fname,
  229.       ofns.size = strlen(ppdev->fname),
  230.       ofns.persistent = false;
  231.     return param_write_string(plist, "OutputFile", &ofns);
  232. }
  233.  
  234. /* Put parameters. */
  235. int
  236. gdev_prn_put_params(gx_device *pdev, gs_param_list *plist)
  237. {    int ecode = 0;
  238.     int code;
  239.     const char _ds *param_name;
  240.     bool is_open = pdev->is_open;
  241.     int nci = ppdev->NumCopies;
  242.     bool ncset = ppdev->NumCopies_set;
  243.     bool oof = ppdev->OpenOutputFile;
  244.     bool duplex;
  245.     int duplex_set = -1;
  246.     int width = pdev->width;
  247.     int height = pdev->height;
  248.     gdev_prn_space_params sp, save_sp;
  249.     gs_param_string ofs;
  250.     gs_param_dict mdict;
  251.  
  252.     sp = ppdev->space_params;
  253.     save_sp = sp;
  254.     switch ( code = param_read_int(plist, (param_name = "NumCopies"), &nci) )
  255.     {
  256.     case 0:
  257.         if ( nci < 0 )
  258.           ecode = gs_error_rangecheck;
  259.         else
  260.           { ncset = true;
  261.             break;
  262.           }
  263.         goto nce;
  264.     default:
  265.         if ( (code = param_read_null(plist, param_name)) == 0 )
  266.           {    ncset = false;
  267.             break;
  268.           }
  269.         ecode = code;    /* can't be 1 */
  270. nce:        param_signal_error(plist, param_name, ecode);
  271.     case 1:
  272.         break;
  273.     }
  274.  
  275.     switch ( code = param_read_bool(plist, (param_name = "OpenOutputFile"), &oof) )
  276.     {
  277.     default:
  278.         ecode = code;
  279.         param_signal_error(plist, param_name, ecode);
  280.     case 0:
  281.     case 1:
  282.         break;
  283.     }
  284.  
  285.     if ( ppdev->Duplex_set >= 0 )    /* i.e., Duplex is supported */
  286.       switch ( code = param_read_bool(plist, (param_name = "Duplex"),
  287.                       &duplex) )
  288.         {
  289.         case 0:
  290.         duplex_set = 1;
  291.         break;
  292.         default:
  293.         if ( (code = param_read_null(plist, param_name)) == 0 )
  294.         {    duplex_set = 0;
  295.             break;
  296.         }
  297.         ecode = code;
  298.         param_signal_error(plist, param_name, ecode);
  299.         case 1:
  300.         ;
  301.         }
  302.  
  303. #define CHECK_PARAM_CASES(bad, label)\
  304.     case 0: if ( bad ) ecode = gs_error_rangecheck; else break; goto label;\
  305.     default: ecode = code;\
  306.   label: param_signal_error(plist, param_name, ecode);\
  307.     case 1: break
  308.  
  309.     switch ( code = param_read_long(plist, (param_name = "MaxBitmap"), &sp.MaxBitmap) )
  310.     {
  311.       CHECK_PARAM_CASES(sp.MaxBitmap < 10000, mbe);
  312.     }
  313.  
  314.     switch ( code = param_read_long(plist, (param_name = "BufferSpace"), &sp.BufferSpace) )
  315.     {
  316.       CHECK_PARAM_CASES(sp.BufferSpace < 10000, bse);
  317.     }
  318.  
  319.     switch ( code = param_read_int(plist, (param_name = "BandWidth"), &sp.band.BandWidth) )
  320.     {
  321.       CHECK_PARAM_CASES(sp.band.BandWidth < 0, bwe);
  322.     }
  323.  
  324.     switch ( code = param_read_int(plist, (param_name = "BandHeight"), &sp.band.BandHeight) )
  325.     {
  326.       CHECK_PARAM_CASES(sp.band.BandHeight < 0, bhe);
  327.     }
  328.  
  329.     switch ( code = param_read_long(plist, (param_name = "BandBufferSpace"), &sp.band.BandBufferSpace) )
  330.     {
  331.       CHECK_PARAM_CASES(sp.band.BandBufferSpace < 0, bbse);
  332.     }
  333.  
  334.     switch ( code = param_read_string(plist, (param_name = "OutputFile"), &ofs) )
  335.     {
  336.     case 0:
  337.         if ( ofs.size >= prn_fname_sizeof )
  338.           ecode = gs_error_limitcheck;
  339.         else
  340.           {    /* Check the validity of any % formats. */
  341.             uint i;
  342.             bool pagenum = false;
  343.             for ( i = 0; i < ofs.size; ++i )
  344.               if ( ofs.data[i] == '%' )
  345.                 { if ( i+1 < ofs.size && ofs.data[i+1] == '%' )
  346.                 continue;
  347.                   if ( pagenum )        /* more than one %, */
  348.                 i = ofs.size - 1;    /* force error */
  349.                   pagenum = true;
  350. sw:                  if ( ++i == ofs.size )
  351.                 { ecode = gs_error_rangecheck;
  352.                   goto ofe;
  353.                 }
  354.                   switch ( ofs.data[i] )
  355.                 {
  356.                 case ' ': case '#': case '+': case '-':
  357.                 case '0': case '1': case '2': case '3':
  358.                 case '4': case '5': case '6': case '7':
  359.                 case '8': case '9': case 'l':
  360.                   goto sw;
  361.                 case 'd': case 'i': case 'u': case 'o':
  362.                 case 'x': case 'X':
  363.                   continue;
  364.                 default:
  365.                   ecode = gs_error_rangecheck;
  366.                   goto ofe;
  367.                 }
  368.                 }
  369.             break;
  370.           }
  371.         goto ofe;
  372.     default:
  373.         ecode = code;
  374. ofe:        param_signal_error(plist, param_name, ecode);
  375.     case 1:
  376.         ofs.data = 0;
  377.         break;
  378.     }
  379.  
  380.     /* Read InputAttributes and OutputAttributes just for the type */
  381.     /* check and to indicate that they aren't undefined. */
  382. #define read_media(pname)\
  383.     switch ( code = param_begin_read_dict(plist, (param_name = pname), &mdict, true) )\
  384.       {\
  385.       case 0:\
  386.         param_end_read_dict(plist, pname, &mdict);\
  387.         break;\
  388.       default:\
  389.         ecode = code;\
  390.         param_signal_error(plist, param_name, ecode);\
  391.       case 1:\
  392.         ;\
  393.       }
  394.  
  395.     read_media("InputAttributes");
  396.     read_media("OutputAttributes");
  397.  
  398.     if ( ecode < 0 )
  399.       return ecode;
  400.     /* Prevent gx_default_put_params from closing the printer. */
  401.     pdev->is_open = false;
  402.     code = gx_default_put_params(pdev, plist);
  403.     pdev->is_open = is_open;
  404.     if ( code < 0 )
  405.       return code;
  406.  
  407.     ppdev->NumCopies = nci;
  408.     ppdev->NumCopies_set = ncset;
  409.     ppdev->OpenOutputFile = oof;
  410.     if ( duplex_set >= 0 )
  411.       { ppdev->Duplex = duplex;
  412.         ppdev->Duplex_set = duplex_set;
  413.       }
  414.     /* If necessary, free and reallocate the printer memory. */
  415.     if ( memcmp(&sp, &save_sp, sizeof(sp)) != 0 ||
  416.          pdev->width != width || pdev->height != height
  417.        )
  418.       {    if ( is_open )
  419.           gdev_prn_free(pdev);
  420.         ppdev->space_params = sp;
  421.         if ( is_open )
  422.           {    ecode = code = gdev_prn_alloc(pdev);
  423.             if ( code < 0 )
  424.               {    /* Try to put things back as they were. */
  425.                 ppdev->space_params = save_sp;
  426.                 gx_device_set_width_height(pdev,
  427.                                width, height);
  428.                 code = gdev_prn_alloc(pdev);
  429.                 if ( code < 0 )
  430.                   {    /* Disaster!  We can't get back. */
  431.                     pdev->is_open = false;
  432.                     return code;
  433.                   }
  434.                 return ecode;
  435.               }
  436.           }
  437.       }
  438.     if ( ofs.data != 0 &&
  439.          bytes_compare(ofs.data, ofs.size,
  440.                (const byte *)ppdev->fname, strlen(ppdev->fname))
  441.        )
  442.       {    /* Close the file if it's open. */
  443.         if ( ppdev->file != NULL && ppdev->file != stdout )
  444.           gp_close_printer(ppdev->file, ppdev->fname);
  445.         ppdev->file = NULL;
  446.         memcpy(ppdev->fname, ofs.data, ofs.size);
  447.         ppdev->fname[ofs.size] = 0;
  448.       }
  449.  
  450.     /* If the device is open and OpenOutputFile is true, */
  451.     /* open the OutputFile now.  (If the device isn't open, */
  452.     /* this will happen when it is opened.) */
  453.     if ( pdev->is_open && oof )
  454.       {    code = gdev_prn_open_printer(pdev, 1);
  455.         if ( code < 0 )
  456.           return code;
  457.       }
  458.  
  459.     return 0;
  460. }
  461.  
  462. /* Put InputAttributes and OutputAttributes. */
  463. int
  464. gdev_prn_input_page_size(int index, gs_param_dict *pdict,
  465.   floatp width_points, floatp height_points)
  466. {    input_media media;
  467.     media.PageSize[0] = width_points;
  468.     media.PageSize[1] = height_points;
  469.     media.MediaColor = 0;
  470.     media.MediaWeight = 0;
  471.     media.MediaType = 0;
  472.     return gdev_prn_input_media(index, pdict, &media);
  473. }
  474. private int
  475. finish_media(gs_param_list *mlist, gs_param_name key, const char *media_type)
  476. {    int code = 0;
  477.     if ( media_type != 0 )
  478.       {    gs_param_string as;
  479.         param_string_from_string(as, media_type);
  480.         code = param_write_string(mlist, key, &as);
  481.       }
  482.     return code;
  483. }
  484. int
  485. gdev_prn_input_media(int index, gs_param_dict *pdict, const input_media *pim)
  486. {    char key[25];
  487.     gs_param_dict mdict;
  488.     int code;
  489.     gs_param_string as;
  490.  
  491.     sprintf(key, "%d", index);
  492.     mdict.size = 4;
  493.     code = param_begin_write_dict(pdict->list, key, &mdict, false);
  494.     if ( code < 0 )
  495.       return code;
  496.     if ( pim->PageSize[0] != 0 && pim->PageSize[1] != 0 )
  497.       {    gs_param_float_array psa;
  498.         psa.data = pim->PageSize, psa.size = 2, psa.persistent = false;
  499.         code = param_write_float_array(mdict.list, "PageSize",
  500.                            &psa);
  501.         if ( code < 0 )
  502.           return code;
  503.       }
  504.     if ( pim->MediaColor != 0 )
  505.       {    param_string_from_string(as, pim->MediaColor);
  506.         code = param_write_string(mdict.list, "MediaColor",
  507.                       &as);
  508.         if ( code < 0 )
  509.           return code;
  510.       }
  511.     if ( pim->MediaWeight != 0 )
  512.       {    /* We do the following silly thing in order to avoid */
  513.         /* having to work around the 'const' in the arg list. */
  514.         float weight = pim->MediaWeight;
  515.         code = param_write_float(mdict.list, "MediaWeight",
  516.                      &weight);
  517.         if ( code < 0 )
  518.           return code;
  519.       }
  520.     code = finish_media(mdict.list, "MediaType", pim->MediaType);
  521.     if ( code < 0 )
  522.       return code;
  523.     return param_end_write_dict(pdict->list, key, &mdict);
  524. }
  525. int
  526. gdev_prn_output_media(int index, gs_param_dict *pdict, const output_media *pom)
  527. {    char key[25];
  528.     gs_param_dict mdict;
  529.     int code;
  530.  
  531.     sprintf(key, "%d", index);
  532.     mdict.size = 4;
  533.     code = param_begin_write_dict(pdict->list, key, &mdict, false);
  534.     if ( code < 0 )
  535.       return code;
  536.     code = finish_media(mdict.list, "OutputType", pom->OutputType);
  537.     if ( code < 0 )
  538.       return code;
  539.     return param_end_write_dict(pdict->list, key, &mdict);
  540. }
  541.  
  542. /* ------ Others ------ */
  543.  
  544. /* Generic routine to send the page to the printer. */
  545. int
  546. gdev_prn_output_page(gx_device *pdev, int num_copies, int flush)
  547. {    int outcode, closecode, errcode, endcode;
  548.  
  549.     if ( num_copies > 0 )
  550.       { int code = gdev_prn_open_printer(pdev, 1);
  551.         if ( code < 0 )
  552.           return code;
  553.  
  554.         /* Print the accumulated page description. */
  555.         outcode =
  556.           (*ppdev->printer_procs.print_page_copies)(ppdev, ppdev->file,
  557.                             num_copies);
  558.         fflush(ppdev->file);
  559.         errcode =
  560.           (ferror(ppdev->file) ? gs_note_error(gs_error_ioerror) : 0);
  561.         closecode = gdev_prn_close_printer(pdev);
  562.       }
  563.     else
  564.       outcode = closecode = errcode = 0;
  565.     endcode = (ppdev->buffer_space ? clist_finish_page(pdev, flush) : 0);
  566.  
  567.     if ( outcode < 0 )
  568.       return outcode;
  569.     if ( errcode < 0 )
  570.       return errcode;
  571.     if ( closecode < 0 )
  572.       return closecode;
  573.     if ( endcode < 0 )
  574.       return endcode;
  575.     return outcode;
  576. }
  577.  
  578. /* Print multiple copies of a page by calling print_page multiple times. */
  579. int
  580. gx_default_print_page_copies(gx_device_printer *pdev, FILE *prn_stream,
  581.   int num_copies)
  582. {    int i = num_copies;
  583.     int code = 0;
  584.     while ( code >= 0 && i-- > 0 )
  585.       code = (*pdev->printer_procs.print_page)(pdev, prn_stream);
  586.     return code;
  587. }
  588.  
  589. /* ---------------- Driver services ---------------- */
  590.  
  591. /* Return the number of scan lines that should actually be passed */
  592. /* to the device. */
  593. int
  594. gdev_prn_print_scan_lines(gx_device *pdev)
  595. {    int height = pdev->height;
  596.     gs_matrix imat;
  597.     float yscale;
  598.     int top, bottom, offset, end;
  599.  
  600.     (*dev_proc(pdev, get_initial_matrix))(pdev, &imat);
  601.     yscale = imat.yy * 72.0;        /* Y dpi, may be negative */
  602.     top = (int)(dev_t_margin(pdev) * yscale);
  603.     bottom = (int)(dev_b_margin(pdev) * yscale);
  604.     offset = (int)(dev_y_offset(pdev) * yscale);
  605.     if ( yscale < 0 )
  606.       {    /* Y=0 is top of page */
  607.         end = -offset + height + bottom;
  608.       }
  609.     else
  610.       {    /* Y=0 is bottom of page */
  611.         end = offset + height - top;
  612.       }
  613.     return min(height, end);
  614. }
  615.  
  616. /* Open the current page for printing. */
  617. int
  618. gdev_prn_open_printer(gx_device *pdev, bool binary_mode)
  619. {    if ( ppdev->file != 0 )
  620.       { ppdev->file_is_new = false;
  621.         return 0;
  622.       }
  623.     { int code = gx_device_open_output_file(pdev, ppdev->fname,
  624.                         binary_mode, false,
  625.                         &ppdev->file);
  626.       if ( code < 0 )
  627.         return code;
  628.     }
  629.     ppdev->file_is_new = true;
  630.     return 0;
  631. }
  632.  
  633. /* Copy a scan line from the buffer to the printer. */
  634. int
  635. gdev_prn_get_bits(gx_device_printer *pdev, int y, byte *str, byte **actual_data)
  636. {    int code = (*dev_proc(pdev, get_bits))((gx_device *)pdev, y, str, actual_data);
  637.     uint line_size = gdev_prn_raster(pdev);
  638.     int last_bits = -(pdev->width * pdev->color_info.depth) & 7;
  639.     if ( code < 0 ) return code;
  640.     if ( last_bits != 0 )
  641.     {    byte *dest = (actual_data != 0 ? *actual_data : str);
  642.         dest[line_size - 1] &= 0xff << last_bits;
  643.     }
  644.     return 0;
  645. }
  646. /* Copy scan lines to a buffer.  Return the number of scan lines, */
  647. /* or <0 if error. */
  648. int
  649. gdev_prn_copy_scan_lines(gx_device_printer *pdev, int y, byte *str, uint size)
  650. {    uint line_size = gdev_prn_raster(pdev);
  651.     int count = size / line_size;
  652.     int i;
  653.     byte *dest = str;
  654.     count = min(count, pdev->height - y);
  655.     for ( i = 0; i < count; i++, dest += line_size )
  656.     {    int code = gdev_prn_get_bits(pdev, y + i, dest, NULL);
  657.         if ( code < 0 ) return code;
  658.     }
  659.     return count;
  660. }
  661.  
  662. /* Close the current page. */
  663. int
  664. gdev_prn_close_printer(gx_device *pdev)
  665. {    if ( strchr(ppdev->fname, '%') )    /* file per page */
  666.        {    gp_close_printer(ppdev->file, ppdev->fname);
  667.         ppdev->file = NULL;
  668.        }
  669.     return 0;
  670. }
  671.